package com.dkd.manage.service.impl;

import java.util.List;

import com.dkd.manage.domain.VendingMachine;
import com.dkd.manage.mapper.VendingMachineMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.dkd.manage.mapper.VmTypeMapper;
import com.dkd.manage.domain.VmType;
import com.dkd.manage.service.IVmTypeService;
import org.springframework.transaction.annotation.Transactional;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 设备类型管理Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-09-09
 */
@Service
public class VmTypeServiceImpl implements IVmTypeService 
{
    private static final Logger log = LoggerFactory.getLogger(VmTypeServiceImpl.class);
    
    @Autowired
    private VmTypeMapper vmTypeMapper;
    @Autowired
    private VendingMachineMapper vendingMachineMapper;

    /**
     * 查询设备类型管理
     * 
     * @param id 设备类型管理主键
     * @return 设备类型管理
     */
    @Override
    public VmType selectVmTypeById(Long id)
    {
        return vmTypeMapper.selectVmTypeById(id);
    }

    /**
     * 查询设备类型管理列表
     * 
     * @param vmType 设备类型管理
     * @return 设备类型管理
     */
    @Override
    public List<VmType> selectVmTypeList(VmType vmType)
    {
        return vmTypeMapper.selectVmTypeList(vmType);
    }

    /**
     * 新增设备类型管理
     * 
     * @param vmType 设备类型管理
     * @return 结果
     */
    @Override
    public int insertVmType(VmType vmType)
    {
        return vmTypeMapper.insertVmType(vmType);
    }

    /**
     * 修改设备类型管理
     * 
     * @param vmType 设备类型管理
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int updateVmType(VmType vmType)
    {
        log.info("开始更新设备类型信息，设备类型ID: {}", vmType.getId());
        
        // 1. 先获取更新前的设备类型信息
        VmType oldVmType = vmTypeMapper.selectVmTypeById(vmType.getId());
        if (oldVmType == null) {
            log.error("设备类型不存在，设备类型ID: {}", vmType.getId());
            throw new RuntimeException("设备类型不存在");
        }
        
        // 2. 更新设备类型表
        int result = vmTypeMapper.updateVmType(vmType);
        if (result <= 0) {
            log.warn("设备类型更新失败，设备类型ID: {}", vmType.getId());
            return result;
        }
        
        // 3. 查询更新后的设备类型信息
        VmType updatedVmType = vmTypeMapper.selectVmTypeById(vmType.getId());
        if (updatedVmType == null) {
            log.error("获取更新后的设备类型信息失败，设备类型ID: {}", vmType.getId());
            throw new RuntimeException("获取更新后的设备类型信息失败");
        }

        // 4. 检查容量是否发生变化
        Long oldCapacity = oldVmType.getChannelMaxCapacity();
        Long newCapacity = updatedVmType.getChannelMaxCapacity();
        
        if (oldCapacity != null && newCapacity != null && oldCapacity.equals(newCapacity)) {
            log.info("设备类型容量未发生变化，无需更新设备表冗余字段，设备类型ID: {}", vmType.getId());
            return result;
        }
        
        log.info("设备类型容量发生变化，旧容量: {}, 新容量: {}, 开始同步设备表冗余字段，设备类型ID: {}", 
                oldCapacity, newCapacity, vmType.getId());

        // 5. 更新设备管理表中的冗余字段：最大容量
        VendingMachine query = new VendingMachine();
        query.setVmTypeId(vmType.getId());
        List<VendingMachine> vmList = vendingMachineMapper.selectVendingMachineList(query);
        
        if (vmList == null || vmList.isEmpty()) {
            log.info("没有设备使用该设备类型，无需更新设备表冗余字段，设备类型ID: {}", vmType.getId());
            return result;
        }
        
        log.info("找到 {} 台设备需要更新冗余字段，设备类型ID: {}", vmList.size(), vmType.getId());
        
        // 6. 遍历设备列表更新冗余字段
        for (VendingMachine vm : vmList) {
            try {
                VendingMachine update = new VendingMachine();
                update.setId(vm.getId());
                update.setChannelMaxCapacity(updatedVmType.getChannelMaxCapacity());
                update.setVmTypeId(updatedVmType.getId());
                
                // 更新设备管理表
                int updateResult = vendingMachineMapper.updateVendingMachine(update);
                if (updateResult > 0) {
                    log.debug("设备冗余字段更新成功，设备ID: {}, 设备类型ID: {}", vm.getId(), vmType.getId());
                } else {
                    log.warn("设备冗余字段更新失败，设备ID: {}, 设备类型ID: {}", vm.getId(), vmType.getId());
                }
            } catch (Exception e) {
                log.error("更新设备冗余字段时发生异常，设备ID: {}, 设备类型ID: {}, 错误信息: {}", 
                         vm.getId(), vmType.getId(), e.getMessage(), e);
                throw e; // 重新抛出异常，触发事务回滚
            }
        }
        
        log.info("设备类型更新完成，设备类型ID: {}, 同步了 {} 台设备的冗余字段", vmType.getId(), vmList.size());
        return result;
    }

    /**
     * 批量删除设备类型管理
     * 
     * @param ids 需要删除的设备类型管理主键
     * @return 结果
     */
    @Override
    public int deleteVmTypeByIds(Long[] ids)
    {
        return vmTypeMapper.deleteVmTypeByIds(ids);
    }

    /**
     * 删除设备类型管理信息
     * 
     * @param id 设备类型管理主键
     * @return 结果
     */
    @Override
    public int deleteVmTypeById(Long id)
    {
        return vmTypeMapper.deleteVmTypeById(id);
    }
}
